﻿#region Copyright (c) 2003 - 2008, Andreas Mueller
/////////////////////////////////////////////////////////////////////////////////////////
// 
// Copyright (c) 2003 - 2008, Andreas Mueller.
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// Contributors:
//    Andreas Mueller - initial API and implementation
//
// 
// This software is derived from software bearing the following
// restrictions:
// 
// Copyright (c) 1994
// Hewlett-Packard Company
// 
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Hewlett-Packard Company makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
// 
// 
// Copyright (c) 1996,1997
// Silicon Graphics Computer Systems, Inc.
// 
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Silicon Graphics makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
// 
// 
// (C) Copyright Nicolai M. Josuttis 1999.
// Permission to copy, use, modify, sell and distribute this software
// is granted provided this copyright notice appears in all copies.
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
// 
/////////////////////////////////////////////////////////////////////////////////////////
#endregion


using NStl.Collections.Private;
using NUnit.Framework;
using NUnit.Framework.SyntaxHelpers;

namespace NStl.NUnit.ContainerFixture.Deque
{
    [TestFixture]
    public class PositionMinusFixture
    {
        [Test]
        public void OpMinusInt()
        {
            Position p = new Position(7, 0);

            Position np = p - 5;
            Position expected = new Position(2, 0);
            Assert.That(np, Is.EqualTo(expected));
        }
        [Test]
        public void GenericOpMinusInt()
        {
            Position p = new Position(2, 2);

            Position[] expected = new Position[]
                {
                    new Position(2, 2),
                    new Position(1, 2),
                    new Position(0, 2),

                    new Position(9, 1),
                    new Position(8, 1),
                    new Position(7, 1),
                    new Position(6, 1),
                    new Position(5, 1),
                    new Position(4, 1),
                    new Position(3, 1),
                    new Position(2, 1),
                    new Position(1, 1),
                    new Position(0, 1),

                    new Position(9, 0),
                    new Position(8, 0),
                    new Position(7, 0),
                    new Position(6, 0),
                    new Position(5, 0),
                    new Position(4, 0),
                    new Position(3, 0),
                    new Position(2, 0),
                    new Position(1, 0),
                    new Position(0, 0),

                    new Position(9, -1),
                    new Position(8, -1),
                    new Position(7, -1),
                    new Position(6, -1),
                    new Position(5, -1),
                    new Position(4, -1),
                    new Position(3, -1),
                    new Position(2, -1),
                    new Position(1, -1),
                    new Position(0, -1),

                    new Position(9, -2),
                    new Position(8, -2),
                    new Position(7, -2),
                    new Position(6, -2),
                    new Position(5, -2),
                    new Position(4, -2),
                    new Position(3, -2),
                    new Position(2, -2),
                    new Position(1, -2),
                    new Position(0, -2),
                    
                };

            for (int i = 0; i < expected.Length; ++i)
            {
                Position np = p - i;
                //System.Console.WriteLine(string.Format("{2} ->\t{0}    {1}", np, expected[i], i));
                Assert.That(np, Is.EqualTo(expected[i]), "At {0}", i);
            }
        }
        [Test]
        public void OpMinusIntFlipsUnderXMinAndOneY()
        {
            Position p = new Position(2, 0);

            Position np = p - Position.xMax - 1;
            Position expected = new Position(1, -1);
            Assert.That(expected, Is.EqualTo(np));
        }
        [Test]
        public void OpMinusIntFlipsOverXMaxAndTwoY()
        {
            Position p = new Position(2, 0);

            Position np = p - 2 * Position.xMax;
            Position expected = new Position(2, -2);
            Assert.That(expected, Is.EqualTo(np));
        }
        [Test]
        public void Minus()
        {
            Position p1 = new Position(2, 5);
            Position p2 = new Position(4, 3);

            int dist = p1 - p2;
            Assert.That(dist, Is.EqualTo(18));
        }

        [Test]
        public void MinusReverse()
        {
            Position p1 = new Position(2, 5);
            Position p2 = new Position(4, 3);

            int dist = p2 - p1;
            Assert.That(dist, Is.EqualTo(-18));
        }

        [Test]
        public void OpMinusMinus()
        {
            Position p = new Position(0, 2);

            --p;

            Position expected = new Position(9, 1);
            Assert.That(p, Is.EqualTo(expected));
        }
    }
}
